This port is a connection point for a control link.
An output control port is ordinarily quiescent. When “poked” by a box it is on, however, it emits an infinitesimally short control “pulse” that can be transmitted instantaneously to other (input) control ports via a control link.
An input control port “listens” for control pulses and notifies the box it is on that such a pulse has been received. It acts exactly like a flip-flop whose value is set to “one” by a received control pulse, and whose value is reset to “zero” by the box it is on. The action of the box in response to a pulse on a particular input control port depends on its function, of course.
61
This is a primitive part in the “Concurrent” interpretation.
633
This port is a connection point for a data link.
An output data port is ordinarily quiescent. When “written to” by a box it is on, however, it emits for an infinitesimally short time a data value that can be transmitted instantaneously to other (input) data ports via a data link.
An input data port “listens” for data values and remembers the data value when it receives one. It acts exactly like a register whose value is set whenever a data value is received. (The new value overwrites any previous value that may have been in this register.) The box it is on may “read” the data value from any input data port at any time.
61
This is a primitive part in the “Concurrent” interpretation.
166
This link transmits a control “pulse” instantaneously from any output control port connected to its left end, to every input control port connected to its right end.
61
This is a primitive part in the “Concurrent” interpretation.
155
This link transmits a data value instantaneously from any output data port connected to its left end, to every input data port connected to its right end.
61
This is a primitive part in the “Concurrent” interpretation.
107
When “start” is poked, values are read from “x” and “y”, their sum is written to “z”, and “done” is poked.
60
start:
{
write (z, read (x) + read (y));
poke (done);
}
0
120
When “start” is poked, values are read from “x” and “y”, their difference (x-y) is written to “z”, and “done” is poked.
60
start:
{
write (z, read (x) - read (y));
poke (done);
}
0
111
When “start” is poked, values are read from “x” and “y”, their product is written to “z”, and “done” is poked.
60
start:
{
write (z, read (x) * read (y));
poke (done);
}
0
291
Initially, the state of this box is such that it thinks none of the control links attached to “ready” has been poked yet.
Exactly when all control links attached to “ready” have been poked at least once, “synchronized” is poked, and the state of this box is reset to its initial condition.
576
boolean *poked;
int number_poked;
int number_needed = size (ready);
/*------------------------------------*/
void reset ()
{
int i;
for (i = number_needed - 1; i >= 0; i--) poked [i] = FALSE;
When “start” is poked, the value of this box’s instance information is written to “z”, and “done” is poked.
64
start:
{
write (z, instance_information ());
poke (done);
}
0
302
Initially, the value of this box’s instance information is written to “z” and “done” is poked.
When “start” is poked, the value is read from “x” and compared to the last value written to “z”. If and only if they are different, the new value just read from “x” is written to “z”, and “done” is poked.
423
real last_value;
/*------------------------------------*/
void write_value ()
{
write (z, last_value);
poke (done);
}
/*------------------------------------*/
init:
{
last_value = instance_information;
write_value ();
}
/*------------------------------------*/
start:
{
real new_value;
new_value = read (x);
if (new_value != last_value)
{
last_value = new_value;
write_value ();
}
}
0
91
When “pass” is poked, a value is read from “x”, it is written to “z”, and “done” is poked.
48
pass:
{
write (z, read (x));
poke (done);
}
0
193
• When “pass1” is poked, the value of “x” is read, it is written to “z1”, and “done1” is poked.
• When “pass2” is poked, the value of “x” is read, it is written to “z2”, and “done2” is poked.
145
pass1:
{
write (z1, read (x));
poke (done1);
}
/*------------------------------------*/
pass2:
{
write (z2, read (x));
poke (done2);
}
0
191
• When “pass1” is poked, the value of “x1” is read, it is written to “z”, and “done” is poked.
• When “pass2” is poked, the value of “x2” is read, it is written to “z”, and “done” is poked.
143
pass1:
{
write (z, read (x1));
poke (done);
}
/*------------------------------------*/
pass2:
{
write (z, read (x2));
poke (done);
}
0
105
When “start” is poked, this box reads “delay” and waits that number of clock ticks before poking “done”.
49
start:
{
hold (read (delay));
poke (done);
}
0
136
When “start” is poked:
• If “x” > 0 then “positive” is poked.
• If “x” = 0 then “zero” is poked.
• If “x” < 0 then “negative” is poked.
133
start:
{
real xx;
xx = read (x);
if (xx > 0) poke (positive);
else if (xx == 0) poke (zero);
else poke (negative);
}
0
168
When “start” is poked, a value obtained from an A/D converter (whose identity is in the instance information for this box) is written to “sample”, and “done” is poked.
78
start:
{
write (sample, A_to_D (instance_information ()));
poke (done);
}
0
167
When “start” is poked, a value is read from “data” and is output to a D/A converter (whose identity is in the instance information for this box), and “done” is poked.
75
start:
{
D_to_A (instance_information (), read (data));
poke (done);
}
0
208
When “on” is poked, a physical switch (whose identity is given by the instance information of this box) is turned on, and “done” is poked. When “off” is poked, the switch is turned off, and “done” is poked.
183
on:
{
set_switch (instance_information (), TRUE);
poke (done);
}
/*------------------------------------*/
off:
{
set_switch (instance_information (), FALSE);
poke (done);
}
0
86
Upon completion of system initialization, “go” is poked. This box does nothing else.
23
init:
{
poke (go);
}
0
107
When “start” is poked, a value is read from “x”, its negation (-x) is written to “z”, and “done” is poked.
50
start:
{
write (z, -read (x));
poke (done);
}
0
114
When “start” is poked, a value is read from “x”, its absolute value (|x|) is written to “z”, and “done” is poked.
101
start:
{
real abs;
abs = read (x);
if (abs < 0) abs = -abs;
write (z, abs);
poke (done);
}
0
180
When “start” is poked, values are read from “x” and “max”. Then one of the following values is written to “z”:
